#ifndef SMART_CONFIG_H
#define SMART_CONFIG_H

#include <pcap.h>
#include <vector>
#include <map>
#include <string>
#include <thread>
#include <atomic>
#include <fstream>
#include <string>
#include <sstream>

#include <iostream> // 添加 iostream 以支持 std::cerr 和 std::cout
#include <chrono>
#include <ctime>
#include <cstdlib>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <csignal>
#include <algorithm>
#include <set>
#include <iomanip> // 确保包含 setw, setfill
#include <endian.h> // 确保包含 le16toh
#include <netinet/in.h> // 确保包含 ntohs
#include <cstring> // 确保包含 memcmp
#include <functional>


#include <mutex>
#include <condition_variable>
#include <queue>
// 全局退出信号，用于控制程序终止
extern std::atomic<bool> g_exit_event;

#define HEADER_LEN 361  // 帧头部长度

// SmartConfig 类：实现 WiFi 智能配网功能，包括数据包嗅探、凭证解析和网络连接
class SmartConfig {
public:
    // 构造函数：初始化日志文件和成员变量
    SmartConfig();

    // 析构函数：关闭日志文件和 pcap 句柄
    ~SmartConfig();

    // 检查是否以 root 权限运行
    void checkRoot();

    // 检查是否已连接到 WiFi 网络
    bool isWifiConnected();

    // 将 ASCII 码转换为可打印字符
    char asciiChar(int code);

    // 重置嗅探状态和数据
    void reset();

    // 解析 WiFi 凭证（格式：SSID:password）
    std::pair<std::string, std::string> parseWifiCredentials(const std::string& credentialsStr);

    // 切换到托管模式（managed mode）
    void switchToManaged(const std::string& monitorIface = "wlan0mon", const std::string& managedIface = "wlan0");

    // 切换到监控模式（monitor mode）
    bool switchToMonitor(const std::string& managedIface = "wlan0", const std::string& monitorIface = "wlan0mon", int timeout = 10, int channel = 6);

    // 广播 ACK 消息以确认连接
    void broadcastAck(int port = 12345, const std::string& ackMessage = "ACK");

    // 初始化 libpcap 捕获
    void initializePcap();

    // 启动数据包嗅探线程
    void startSniffing();

    // 数据包处理回调函数（静态）
    static void handlePacket(u_char* userData, const struct pcap_pkthdr* pkthdr, const u_char* packet);

    // 处理捕获的数据包
    void processPacket(const struct pcap_pkthdr* pkthdr, const u_char* packet);

    // 处理 WiFi 连接逻辑
    void handleWifiConnection(const std::string& wifiString);

    // 执行 WiFi 连接
    bool establishWifiConnection(const std::string& ssid, const std::string& password, const std::string& monitorIface = "wlan0mon", const std::string& managedIface = "wlan0");

    // 恢复到监控模式
    void recoverToMonitor();

    // 查找重复的凭证字符串
    std::string findDuplicateString();

    // 扫描信道并选择最佳信道
    void scanChannels(const std::string& iface = "wlan0mon", const std::vector<int>& channels = {1, 6, 11}, int duration = 1);

    // 记录日志到文件和控制台
    void log(const std::string& message);

    void handleCheckTargetData();

    void processPackets();
    void capturePackets(pcap_t* handle);

    // 公共成员变量
    std::string INTERFACE;                 // 当前网络接口
    std::thread sniffing_thread;           // 嗅探线程

    std::condition_variable targetDataCV;
    std::queue<std::pair<struct pcap_pkthdr, std::vector<u_char>>> packetQueue;
    std::mutex queueMutex;
    std::condition_variable queueCV;
    std::atomic<bool> done;

    std::vector<std::string> target_data;
    std::mutex targetDataMutex;
    std::mutex dataMutex;  // 新增互斥锁

    std::thread captureThread;
    std::vector<std::thread> processThreads;
    pcap_t* pcap_handle;                   // libpcap 句柄

private:
    bool is_active;                        // 嗅探是否激活
    std::vector<int> frame_data;           // 捕获的帧数据
    std::map<int, char> data_dict;         // 解码字符映射
    int total_len;                         // 总长度
    std::vector<int> total_len_list;       // 总长度候选列表
    int total_len_count;                   // 总长度计数
    int current_index;                     // 当前索引
    // std::vector<std::string> target_data;  // 解码结果集合
    bool has_check_repeat_flag;            // 是否检查重复标志
    const std::string BROADCAST_MAC;       // 广播 MAC 地址
    const int ASCII_START;                 // 开始帧标识
    const int ASCII_END;                   // 结束帧标识
    std::ofstream logger;                  // 日志文件流
    int currentChannel = 0;
    std::map<int, int> packetCounts;
    int wifi_channel;
    // 添加静态映射存储线程ID和名称
    static std::map<std::thread::id, std::string> threadNames;
    // 添加互斥锁保证线程安全
    static std::mutex threadNamesMutex; // 保护 threadNames
    static std::mutex logMutex;         // 保护日志输出


    
    // 将整数向量转换为字符串
    std::string vectorToString(const std::vector<int>& vec);

    // 将字符串向量转换为字符串
    std::string vectorToString(const std::vector<std::string>& vec);

    // 将字符映射转换为字符串
    std::string mapToString(const std::map<int, char>& m);

    // 设置无线接口信道
    bool setChannel(const std::string& iface, int channel);
    static void counterCallback(u_char* userData, const struct pcap_pkthdr* pkthdr, const u_char* packet);
};

std::map<std::thread::id, std::string> SmartConfig::threadNames;
std::mutex SmartConfig::threadNamesMutex;
std::mutex SmartConfig::logMutex;

#endif // SMART_CONFIG_H